Implements ArrayAggregate on the GPU for lambdas decomposable as
(acc, x) -> acc + g(x) with an identity finish. Other shapes fall back
to the CPU.

- ArrayAggregateDecomposer: match merge body against Add(acc, g),
  unwrap Cast on the acc side, validate finish is identity
- GpuArrayAggregate: evaluate g(x) via the existing
  GpuArrayTransformBase explode path, then listReduce + combine with
  zero. Uses NullPolicy.INCLUDE so null elements poison the sum, matching
  Spark's iterative `acc + null = null` semantics. Empty (non-null) lists
  are substituted with op's identity before the add-zero step; null
  lists stay null and propagate.
- Decimal identity scalar is bound to the column's DType (via
  Scalar.fromDecimal(BigInteger, DType)) so ifElse / add don't trip on
  DECIMAL32-vs-DECIMAL128 width mismatches.
- Unit tests for the decomposer and integration tests covering the
  client pattern, null / empty arrays, non-zero init, outer-column refs,
  struct-field access, long overflow, decimal sum, and fallback cases.

Addresses part of NVIDIA#8532.
A follow-up refactor will introduce a normalize pass and AggOp trait
to support PRODUCT / MIN / MAX / AND / OR and Cast stripping.

Co-Authored-By: Claude Opus 4.7 (1M context) <noreply@anthropic.com>

cuDF's segmented max / min and the combineWithZero compare + ifElse both follow
IEEE 754, where fmax(NaN, x) = x (NaN is absorbed). Spark's Greatest / Least use
Double.compare, which treats NaN as larger than every other value and propagates
it. For an array column containing NaN, GPU would return a non-NaN result while
CPU would return NaN — a data-correctness divergence flagged on the PR.

Since customer workloads for ArrayAggregate MAX / MIN are integral-typed, take
the conservative route: narrow ExtremumOp.supportsType to
{Byte, Short, Int, Long} and fall back to CPU on Float / Double. Precise
NaN propagation would require two extra segmented reduces per batch and
explicit NaN handling in combineWithZero; leaving that for a follow-up if a
real workload needs it.

Added an integration test that verifies the Float / Double fallback.

ExtremumOp.supportsType already rejects Float/Double, so the per-type cascade
in MaxOp.identityScalar and MinOp.identityScalar will never see them today.
Remove the dead arms to keep the code honest; they can be added back when a
follow-up adds real NaN propagation.

Previously `nullable = argument.nullable`, which is incorrect when the outer
list is non-nullable but its elements can be null. For INCLUDE-policy ops
(SUM / PRODUCT), a null element anywhere in a non-null list poisons the
accumulator and yields a null output row. Reporting nullable=false in that
case can let the Spark optimizer elide null checks and cause silent wrong
results downstream.

Spark's own ArrayAggregate.nullable returns `argument.nullable ||
finish.nullable`, and the finish lambda's acc variable is always bound with
nullable=true (see ArrayAggregate.bind's `zero.dataType -> true`), so the
CPU side is effectively always true. Match that.

… int tests

- AllOp / AnyOp combineWithZero now pass outDType to cuDF's and / or (ProductOp
  and SumOp were already doing this via add / mul). MaxOp / MinOp use ifElse,
  which has no outType argument; the output type there is determined by the
  inputs (both reduced and zero carry outDType already).

- ArrayAggregateDecomposition now stores the g sub-expression directly instead
  of a gChildIndex. convertToGpuImpl locates the GPU g via fastEquals under the
  merge body's meta children rather than positional indexing, so we don't rely
  on the Add / Multiply / And / Or / Greatest / Least meta-children happening
  to be laid out as [left, right]. Decomposer unit tests assert on g identity.

- Each val-chain boundary in columnarEval is now wrapped in closeOnExcept(x) {
  _ => withResource(x) { ... } } so the transitional window between a step's
  result being assigned and the next withResource taking ownership is covered.
  cuDF's ColumnVector.close is refcount-based, so the rare double-close on
  exception paths is benign.

- Added a parametric native-integer integration test hitting int / long SUM,
  int MAX, and long MIN without the Cast-to-BIGINT that the existing numeric
  test uses, exercising identityScalar / combineWithZero on the primitive
  types directly.

Signed-off-by: Haoyang Li <haoyangl@nvidia.com>

…gg.enabled

cuDF's parallel tree-reduction sums in a different order than Spark's sequential
left-fold, so GPU vs CPU can differ in the low bits on Float/Double. Reuse the
same conf gate as scalar GpuSum/GpuAverage (spark.rapids.sql.variableFloatAgg.enabled)
via GpuOverrides.checkAndTagFloatAgg in GpuArrayAggregateMeta. Default true
matches the global policy. Added integration test for the conf=false fallback path.

Co-Authored-By: Claude Opus 4.7 (1M context) <noreply@anthropic.com>